{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "61330204-a407-449f-af77-fcd868546651",
        "showInput": false
      },
      "source": [
        "## Noisy, Parallel, Multi-Objective BO in BoTorch with qEHVI, qNEHVI, and qNParEGO\n",
        "\n",
        "In this tutorial, we illustrate how to implement a simple multi-objective (MO) Bayesian Optimization (BO) closed loop in BoTorch.\n",
        "\n",
        "In general, we recommend using [Ax](https://ax.dev) for a simple BO setup like this one, since this will simplify your setup (including the amount of code you need to write) considerably. See [here](https://ax.dev/docs/tutorials/multiobjective_optimization.html) for an Ax tutorial on MOBO. If desired, you can use a custom BoTorch model in Ax, following Ax's [Modular BoTorch tutorial](https://ax.dev/docs/tutorials/modular_botorch/) tutorial. Given a `MultiObjective`, Ax will default to the $q$NEHVI acquisiton function. If desired, this can also be customized by adding `\"botorch_acqf_class\": <desired_botorch_acquisition_function_class>,` to the `model_kwargs`.\n",
        "\n",
        "We use the parallel ParEGO ($q$ParEGO) [1], parallel Expected Hypervolume Improvement ($q$EHVI) [1], and parallel Noisy Expected Hypervolume Improvement ($q$NEHVI) [2]  acquisition functions to optimize a synthetic BraninCurrin problem test function with additive Gaussian observation noise over a 2-parameter search space [0,1]^2. See  `botorch/test_functions/multi_objective.py` for details on BraninCurrin. The noise standard deviations are 15.19 and 0.63 for each objective, respectively.\n",
        "\n",
        "Since botorch assumes a maximization of all objectives, we seek to find the Pareto frontier, the set of optimal trade-offs where improving one metric means deteriorating another.\n",
        "\n",
        "[1] [S. Daulton, M. Balandat, and E. Bakshy. Differentiable Expected Hypervolume Improvement for Parallel Multi-Objective Bayesian Optimization. Advances in Neural Information Processing Systems 33, 2020.](https://arxiv.org/abs/2006.05078)\n",
        "\n",
        "[2] [S. Daulton, M. Balandat, and E. Bakshy. Parallel Bayesian Optimization of Multiple Noisy Objectives with Expected Hypervolume Improvement. Advances in Neural Information Processing Systems 34, 2021.](https://arxiv.org/abs/2105.08195)\n",
        "\n",
        "**For batch optimization (or in noisy settings), we strongly recommend using $q$NEHVI rather than $q$EHVI because it is far more efficient than $q$EHVI and mathematically equivalent in the noiseless setting.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "f01416cb-e83e-4263-b599-b2a3221d144d",
        "showInput": false
      },
      "source": [
        "### Set dtype and device\n",
        "Note: $q$EHVI and $q$NEHVI aggressively exploit parallel hardware and are both much faster when run on a GPU. See [1, 2] for details."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Install dependencies if we are running in colab\n",
        "import sys\n",
        "if 'google.colab' in sys.modules:\n",
        "    %pip install botorch"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649461840,
        "executionStopTime": 1668649461848,
        "originalKey": "41c30177-379b-4e63-9996-41bc17d70769",
        "requestMsgId": "7e4820a5-df3b-45a6-9826-42541ee0f4f4"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import torch\n",
        "\n",
        "\n",
        "tkwargs = {\n",
        "    \"dtype\": torch.double,\n",
        "    \"device\": torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\"),\n",
        "}\n",
        "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "8d895a93-397c-4d2c-b6f5-96f589312538",
        "showInput": false
      },
      "source": [
        "### Problem setup\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649462081,
        "executionStopTime": 1668649462087,
        "originalKey": "a8741d41-72b7-42e8-bd5d-3972be9995f7",
        "requestMsgId": "bceaa0af-ffe5-415a-a5b1-93fc9cf7f71a"
      },
      "outputs": [],
      "source": [
        "from botorch.test_functions.multi_objective import BraninCurrin\n",
        "\n",
        "\n",
        "problem = BraninCurrin(negate=True).to(**tkwargs)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "fc047039-c2a9-4ea8-920e-c057547cfb11",
        "showInput": false
      },
      "source": [
        "#### Model initialization\n",
        "\n",
        "We use a list of `SingleTaskGP`s to model the two objectives with known noise variances. If no noise variances were provided, `SingleTaskGP` would infer (homoskedastic) noise levels instead.\n",
        "\n",
        "The models are initialized with $2(d+1)=6$ points drawn randomly from $[0,1]^2$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649462312,
        "executionStopTime": 1668649462318,
        "originalKey": "47170c31-65e4-4f2d-949c-d91544e065fc",
        "requestMsgId": "8a44b7cb-cc5f-419e-849f-2b4d1dc3abe1"
      },
      "outputs": [],
      "source": [
        "from botorch.models.gp_regression import SingleTaskGP\n",
        "from botorch.models.model_list_gp_regression import ModelListGP\n",
        "from gpytorch.mlls.sum_marginal_log_likelihood import SumMarginalLogLikelihood\n",
        "from botorch.utils.transforms import unnormalize, normalize\n",
        "from botorch.utils.sampling import draw_sobol_samples\n",
        "\n",
        "NOISE_SE = torch.tensor([15.19, 0.63], **tkwargs)\n",
        "\n",
        "\n",
        "def generate_initial_data(n=6):\n",
        "    # generate training data\n",
        "    train_x = draw_sobol_samples(bounds=problem.bounds, n=n, q=1).squeeze(1)\n",
        "    train_obj_true = problem(train_x)\n",
        "    train_obj = train_obj_true + torch.randn_like(train_obj_true) * NOISE_SE\n",
        "    return train_x, train_obj, train_obj_true\n",
        "\n",
        "\n",
        "def initialize_model(train_x, train_obj):\n",
        "    # define models for objective and constraint\n",
        "    train_x = normalize(train_x, problem.bounds)\n",
        "    models = []\n",
        "    for i in range(train_obj.shape[-1]):\n",
        "        train_y = train_obj[..., i : i + 1]\n",
        "        train_yvar = torch.full_like(train_y, NOISE_SE[i] ** 2)\n",
        "        models.append(\n",
        "            SingleTaskGP(train_x, train_y, train_yvar)\n",
        "        )\n",
        "    model = ModelListGP(*models)\n",
        "    mll = SumMarginalLogLikelihood(model.likelihood, model)\n",
        "    return mll, model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "6bfaef9a-3f34-4d51-9700-fbddc79eccf1",
        "showInput": false
      },
      "source": [
        "#### Define a helper functions that performs the essential BO step for $q$EHVI and $q$NEHVI\n",
        "The helper function below initializes the $q$EHVI acquisition function, optimizes it, and returns the batch $\\{x_1, x_2, \\ldots x_q\\}$ along with the observed function values. \n",
        "\n",
        "For this example, we'll use a relatively small batch of optimization ($q=4$). For batch optimization ($q>1$), passing the keyword argument `sequential=True` to the function `optimize_acqf`specifies that candidates should be optimized in a sequential greedy fashion (see [1] for details why this is important). A simple initialization heuristic is used to select the 10 restart initial locations from a set of 512 random points. Multi-start optimization of the acquisition function is performed using LBFGS-B with exact gradients computed via auto-differentiation.\n",
        "\n",
        "**Reference Point**\n",
        "\n",
        "$q$EHVI requires specifying a reference point, which is the lower bound on the objectives used for computing hypervolume. In this tutorial, we assume the reference point is known. In practice the reference point can be set 1) using domain knowledge to be slightly worse than the lower bound of objective values, where the lower bound is the minimum acceptable value of interest for each objective, or 2) using a dynamic reference point selection strategy.\n",
        "\n",
        "**Partitioning the Non-dominated Space into disjoint rectangles**\n",
        "\n",
        "$q$EHVI requires partitioning the non-dominated space into disjoint rectangles (see [1] for details). \n",
        "\n",
        "*Note:* `FastNondominatedPartitioning` *will be very slow when 1) there are a lot of points on the pareto frontier and 2) there are >5 objectives.*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649462539,
        "executionStopTime": 1668649462641,
        "originalKey": "b7effe94-1327-405d-9148-c8e93470b846",
        "requestMsgId": "40a5edda-3bee-43c9-b84b-c669c288eb80"
      },
      "outputs": [],
      "source": [
        "from botorch.optim.optimize import optimize_acqf, optimize_acqf_list\n",
        "from botorch.acquisition.objective import GenericMCObjective\n",
        "from botorch.utils.multi_objective.scalarization import get_chebyshev_scalarization\n",
        "from botorch.utils.multi_objective.box_decompositions.non_dominated import (\n",
        "    FastNondominatedPartitioning,\n",
        ")\n",
        "from botorch.acquisition.multi_objective.monte_carlo import (\n",
        "    qExpectedHypervolumeImprovement,\n",
        "    qNoisyExpectedHypervolumeImprovement,\n",
        ")\n",
        "from botorch.utils.sampling import sample_simplex\n",
        "\n",
        "\n",
        "BATCH_SIZE = 4\n",
        "NUM_RESTARTS = 10 if not SMOKE_TEST else 2\n",
        "RAW_SAMPLES = 512 if not SMOKE_TEST else 4\n",
        "\n",
        "standard_bounds = torch.zeros(2, problem.dim, **tkwargs)\n",
        "standard_bounds[1] = 1\n",
        "\n",
        "\n",
        "def optimize_qehvi_and_get_observation(model, train_x, train_obj, sampler):\n",
        "    \"\"\"Optimizes the qEHVI acquisition function, and returns a new candidate and observation.\"\"\"\n",
        "    # partition non-dominated space into disjoint rectangles\n",
        "    with torch.no_grad():\n",
        "        pred = model.posterior(normalize(train_x, problem.bounds)).mean\n",
        "    partitioning = FastNondominatedPartitioning(\n",
        "        ref_point=problem.ref_point,\n",
        "        Y=pred,\n",
        "    )\n",
        "    acq_func = qExpectedHypervolumeImprovement(\n",
        "        model=model,\n",
        "        ref_point=problem.ref_point,\n",
        "        partitioning=partitioning,\n",
        "        sampler=sampler,\n",
        "    )\n",
        "    # optimize\n",
        "    candidates, _ = optimize_acqf(\n",
        "        acq_function=acq_func,\n",
        "        bounds=standard_bounds,\n",
        "        q=BATCH_SIZE,\n",
        "        num_restarts=NUM_RESTARTS,\n",
        "        raw_samples=RAW_SAMPLES,  # used for intialization heuristic\n",
        "        options={\"batch_limit\": 5, \"maxiter\": 200},\n",
        "        sequential=True,\n",
        "    )\n",
        "    # observe new values\n",
        "    new_x = unnormalize(candidates.detach(), bounds=problem.bounds)\n",
        "    new_obj_true = problem(new_x)\n",
        "    new_obj = new_obj_true + torch.randn_like(new_obj_true) * NOISE_SE\n",
        "    return new_x, new_obj, new_obj_true"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "ccaf56e2-f0e0-4d1c-bf07-247d984535a5",
        "showInput": false
      },
      "source": [
        "**Integrating over function values at in-sample designs**\n",
        "\n",
        "$q$NEHVI integrates over the unknown function values at the previously evaluated designs (see [2] for details). Therefore, we need to provide the previously evaluated designs (`train_x`, *normalized* to be within $[0,1]^d$) to the acquisition function.\n",
        "\n",
        "**Efficient batch generation with Cached Box Decomposition (CBD)**\n",
        "\n",
        "$q$NEHVI leveraged CBD to efficiently generate large batches of candidates. CBD scales polynomially with respect to the batch size where as the inclusion-exclusion principle used by qEHVI scales exponentially with the batch size.\n",
        "\n",
        "**Pruning baseline designs**\n",
        "To speed up integration over the function values at the previously evaluated designs, we prune the set of previously evaluated designs (by setting `prune_baseline=True`) to only include those which have positive probability of being on the current in-sample Pareto frontier."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649462860,
        "executionStopTime": 1668649462867,
        "originalKey": "f2749e5f-eb94-4150-8f52-057f90e08b39",
        "requestMsgId": "f9e71b3c-2eb6-4b79-92c5-72d16d368233"
      },
      "outputs": [],
      "source": [
        "def optimize_qnehvi_and_get_observation(model, train_x, train_obj, sampler):\n",
        "    \"\"\"Optimizes the qEHVI acquisition function, and returns a new candidate and observation.\"\"\"\n",
        "    # partition non-dominated space into disjoint rectangles\n",
        "    acq_func = qNoisyExpectedHypervolumeImprovement(\n",
        "        model=model,\n",
        "        ref_point=problem.ref_point.tolist(),  # use known reference point\n",
        "        X_baseline=normalize(train_x, problem.bounds),\n",
        "        prune_baseline=True,  # prune baseline points that have estimated zero probability of being Pareto optimal\n",
        "        sampler=sampler,\n",
        "    )\n",
        "    # optimize\n",
        "    candidates, _ = optimize_acqf(\n",
        "        acq_function=acq_func,\n",
        "        bounds=standard_bounds,\n",
        "        q=BATCH_SIZE,\n",
        "        num_restarts=NUM_RESTARTS,\n",
        "        raw_samples=RAW_SAMPLES,  # used for intialization heuristic\n",
        "        options={\"batch_limit\": 5, \"maxiter\": 200},\n",
        "        sequential=True,\n",
        "    )\n",
        "    # observe new values\n",
        "    new_x = unnormalize(candidates.detach(), bounds=problem.bounds)\n",
        "    new_obj_true = problem(new_x)\n",
        "    new_obj = new_obj_true + torch.randn_like(new_obj_true) * NOISE_SE\n",
        "    return new_x, new_obj, new_obj_true"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "ad78607d-d910-441c-903b-b15dc77a432f",
        "showInput": false
      },
      "source": [
        "#### Define a helper function that performs the essential BO step for $q$NParEGO\n",
        "The helper function below similarly initializes $q$NParEGO, optimizes it, and returns the batch $\\{x_1, x_2, \\ldots x_q\\}$ along with the observed function values. \n",
        "\n",
        "$q$NParEGO uses random augmented chebyshev scalarization with the `qNoisyExpectedImprovement` acquisition function. In the parallel setting ($q>1$), each candidate is optimized in sequential greedy fashion using a different random scalarization (see [1] for details).\n",
        "\n",
        "To do this, we create a list of `qNoisyExpectedImprovement` acquisition functions, each with different random scalarization weights. The `optimize_acqf_list` method sequentially generates one candidate per acquisition function and conditions the next candidate (and acquisition function) on the previously selected pending candidates."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649463087,
        "executionStopTime": 1668649463185,
        "originalKey": "806b115f-a15f-44df-b7f9-d2f098969e02",
        "requestMsgId": "514d162f-78e0-447a-a483-c923cba18b80"
      },
      "outputs": [],
      "source": [
        "from botorch.acquisition.monte_carlo import qNoisyExpectedImprovement\n",
        "\n",
        "\n",
        "def optimize_qnparego_and_get_observation(model, train_x, train_obj, sampler):\n",
        "    \"\"\"Samples a set of random weights for each candidate in the batch, performs sequential greedy optimization\n",
        "    of the qNParEGO acquisition function, and returns a new candidate and observation.\"\"\"\n",
        "    train_x = normalize(train_x, problem.bounds)\n",
        "    with torch.no_grad():\n",
        "        pred = model.posterior(train_x).mean\n",
        "    acq_func_list = []\n",
        "    for _ in range(BATCH_SIZE):\n",
        "        weights = sample_simplex(problem.num_objectives, **tkwargs).squeeze()\n",
        "        objective = GenericMCObjective(\n",
        "            get_chebyshev_scalarization(weights=weights, Y=pred)\n",
        "        )\n",
        "        acq_func = qNoisyExpectedImprovement(  # pyre-ignore: [28]\n",
        "            model=model,\n",
        "            objective=objective,\n",
        "            X_baseline=train_x,\n",
        "            sampler=sampler,\n",
        "            prune_baseline=True,\n",
        "        )\n",
        "        acq_func_list.append(acq_func)\n",
        "    # optimize\n",
        "    candidates, _ = optimize_acqf_list(\n",
        "        acq_function_list=acq_func_list,\n",
        "        bounds=standard_bounds,\n",
        "        num_restarts=NUM_RESTARTS,\n",
        "        raw_samples=RAW_SAMPLES,  # used for intialization heuristic\n",
        "        options={\"batch_limit\": 5, \"maxiter\": 200},\n",
        "    )\n",
        "    # observe new values\n",
        "    new_x = unnormalize(candidates.detach(), bounds=problem.bounds)\n",
        "    new_obj_true = problem(new_x)\n",
        "    new_obj = new_obj_true + torch.randn_like(new_obj_true) * NOISE_SE\n",
        "    return new_x, new_obj, new_obj_true"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "f8ffd86a-f4bb-4984-9330-04ff4d62f189",
        "showInput": false
      },
      "source": [
        "### Perform Bayesian Optimization loop with $q$NEHVI, $q$EHVI, and $q$NParEGO\n",
        "The Bayesian optimization \"loop\" for a batch size of $q$ simply iterates the following steps:\n",
        "1. given a surrogate model, choose a batch of points $\\{x_1, x_2, \\ldots x_q\\}$\n",
        "2. observe $f(x)$ for each $x$ in the batch \n",
        "3. update the surrogate model. \n",
        "\n",
        "\n",
        "Just for illustration purposes, we run one trial with `N_BATCH=20` rounds of optimization. The acquisition function is approximated using `MC_SAMPLES=128` samples.\n",
        "\n",
        "*Note*: Running this may take a little while."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649463513,
        "executionStopTime": 1668649856754,
        "originalKey": "c29b731a-64e7-401d-a5b2-3879d8d39327",
        "requestMsgId": "43e1021f-9ecd-4d2c-a7ba-21e26051ce66"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Batch  1: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 0.00, 0.32, 2.37), time = 29.48.\n",
            "\n",
            "Batch  2: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 31.64, 27.56, 34.87), time = 19.98.\n",
            "\n",
            "Batch  3: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 31.64, 39.05, 48.44), time = 19.73.\n",
            "\n",
            "Batch  4: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 31.77, 47.75, 48.44), time = 17.50.\n",
            "\n",
            "Batch  5: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 31.77, 52.17, 48.44), time = 17.87.\n",
            "\n",
            "Batch  6: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 39.70, 53.12, 50.71), time = 13.42.\n",
            "\n",
            "Batch  7: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 45.20, 53.12, 53.03), time = 17.19.\n",
            "\n",
            "Batch  8: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 45.20, 53.93, 55.20), time = 18.76.\n",
            "\n",
            "Batch  9: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 47.48, 54.05, 55.48), time = 18.70.\n",
            "\n",
            "Batch 10: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 50.86, 54.26, 55.61), time = 16.88.\n",
            "\n",
            "Batch 11: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 50.86, 54.39, 56.15), time = 17.31.\n",
            "\n",
            "Batch 12: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 50.86, 54.56, 56.63), time = 17.12.\n",
            "\n",
            "Batch 13: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 50.86, 55.72, 57.04), time = 19.59.\n",
            "\n",
            "Batch 14: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 51.15, 55.80, 57.12), time = 16.62.\n",
            "\n",
            "Batch 15: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 51.15, 55.86, 57.12), time = 23.50.\n",
            "\n",
            "Batch 16: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 51.86, 55.91, 57.12), time = 17.27.\n",
            "\n",
            "Batch 17: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 52.02, 55.96, 57.42), time = 20.15.\n",
            "\n",
            "Batch 18: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.00, 53.68, 55.98, 57.50), time = 22.07.\n",
            "\n",
            "Batch 19: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.64, 53.95, 56.02, 57.57), time = 20.06.\n",
            "\n",
            "Batch 20: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = (0.64, 54.32, 56.03, 57.77), time = 26.89."
          ]
        }
      ],
      "source": [
        "import time\n",
        "import warnings\n",
        "\n",
        "from botorch import fit_gpytorch_mll\n",
        "from botorch.exceptions import BadInitialCandidatesWarning\n",
        "from botorch.sampling.normal import SobolQMCNormalSampler\n",
        "from botorch.utils.multi_objective.box_decompositions.dominated import (\n",
        "    DominatedPartitioning,\n",
        ")\n",
        "from botorch.utils.multi_objective.pareto import is_non_dominated\n",
        "\n",
        "\n",
        "warnings.filterwarnings(\"ignore\", category=BadInitialCandidatesWarning)\n",
        "warnings.filterwarnings(\"ignore\", category=RuntimeWarning)\n",
        "\n",
        "N_BATCH = 20 if not SMOKE_TEST else 5\n",
        "MC_SAMPLES = 128 if not SMOKE_TEST else 16\n",
        "\n",
        "verbose = True\n",
        "\n",
        "hvs_qparego, hvs_qehvi, hvs_qnehvi, hvs_random = [], [], [], []\n",
        "\n",
        "# call helper functions to generate initial training data and initialize model\n",
        "train_x_qparego, train_obj_qparego, train_obj_true_qparego = generate_initial_data(\n",
        "    n=2 * (problem.dim + 1)\n",
        ")\n",
        "mll_qparego, model_qparego = initialize_model(train_x_qparego, train_obj_qparego)\n",
        "\n",
        "train_x_qehvi, train_obj_qehvi, train_obj_true_qehvi = (\n",
        "    train_x_qparego,\n",
        "    train_obj_qparego,\n",
        "    train_obj_true_qparego,\n",
        ")\n",
        "train_x_qnehvi, train_obj_qnehvi, train_obj_true_qnehvi = (\n",
        "    train_x_qparego,\n",
        "    train_obj_qparego,\n",
        "    train_obj_true_qparego,\n",
        ")\n",
        "train_x_random, train_obj_random, train_obj_true_random = (\n",
        "    train_x_qparego,\n",
        "    train_obj_qparego,\n",
        "    train_obj_true_qparego,\n",
        ")\n",
        "mll_qehvi, model_qehvi = initialize_model(train_x_qehvi, train_obj_qehvi)\n",
        "mll_qnehvi, model_qnehvi = initialize_model(train_x_qnehvi, train_obj_qnehvi)\n",
        "\n",
        "# compute hypervolume\n",
        "bd = DominatedPartitioning(ref_point=problem.ref_point, Y=train_obj_true_qparego)\n",
        "volume = bd.compute_hypervolume().item()\n",
        "\n",
        "hvs_qparego.append(volume)\n",
        "hvs_qehvi.append(volume)\n",
        "hvs_qnehvi.append(volume)\n",
        "hvs_random.append(volume)\n",
        "\n",
        "# run N_BATCH rounds of BayesOpt after the initial random batch\n",
        "for iteration in range(1, N_BATCH + 1):\n",
        "\n",
        "    t0 = time.monotonic()\n",
        "\n",
        "    # fit the models\n",
        "    fit_gpytorch_mll(mll_qparego)\n",
        "    fit_gpytorch_mll(mll_qehvi)\n",
        "    fit_gpytorch_mll(mll_qnehvi)\n",
        "\n",
        "    # define the qEI and qNEI acquisition modules using a QMC sampler\n",
        "    qparego_sampler = SobolQMCNormalSampler(sample_shape=torch.Size([MC_SAMPLES]))\n",
        "    qehvi_sampler = SobolQMCNormalSampler(sample_shape=torch.Size([MC_SAMPLES]))\n",
        "    qnehvi_sampler = SobolQMCNormalSampler(sample_shape=torch.Size([MC_SAMPLES]))\n",
        "\n",
        "    # optimize acquisition functions and get new observations\n",
        "    (\n",
        "        new_x_qparego,\n",
        "        new_obj_qparego,\n",
        "        new_obj_true_qparego,\n",
        "    ) = optimize_qnparego_and_get_observation(\n",
        "        model_qparego, train_x_qparego, train_obj_qparego, qparego_sampler\n",
        "    )\n",
        "    new_x_qehvi, new_obj_qehvi, new_obj_true_qehvi = optimize_qehvi_and_get_observation(\n",
        "        model_qehvi, train_x_qehvi, train_obj_qehvi, qehvi_sampler\n",
        "    )\n",
        "    (\n",
        "        new_x_qnehvi,\n",
        "        new_obj_qnehvi,\n",
        "        new_obj_true_qnehvi,\n",
        "    ) = optimize_qnehvi_and_get_observation(\n",
        "        model_qnehvi, train_x_qnehvi, train_obj_qnehvi, qnehvi_sampler\n",
        "    )\n",
        "    new_x_random, new_obj_random, new_obj_true_random = generate_initial_data(\n",
        "        n=BATCH_SIZE\n",
        "    )\n",
        "\n",
        "    # update training points\n",
        "    train_x_qparego = torch.cat([train_x_qparego, new_x_qparego])\n",
        "    train_obj_qparego = torch.cat([train_obj_qparego, new_obj_qparego])\n",
        "    train_obj_true_qparego = torch.cat([train_obj_true_qparego, new_obj_true_qparego])\n",
        "\n",
        "    train_x_qehvi = torch.cat([train_x_qehvi, new_x_qehvi])\n",
        "    train_obj_qehvi = torch.cat([train_obj_qehvi, new_obj_qehvi])\n",
        "    train_obj_true_qehvi = torch.cat([train_obj_true_qehvi, new_obj_true_qehvi])\n",
        "\n",
        "    train_x_qnehvi = torch.cat([train_x_qnehvi, new_x_qnehvi])\n",
        "    train_obj_qnehvi = torch.cat([train_obj_qnehvi, new_obj_qnehvi])\n",
        "    train_obj_true_qnehvi = torch.cat([train_obj_true_qnehvi, new_obj_true_qnehvi])\n",
        "\n",
        "    train_x_random = torch.cat([train_x_random, new_x_random])\n",
        "    train_obj_random = torch.cat([train_obj_random, new_obj_random])\n",
        "    train_obj_true_random = torch.cat([train_obj_true_random, new_obj_true_random])\n",
        "\n",
        "    # update progress\n",
        "    for hvs_list, train_obj in zip(\n",
        "        (hvs_random, hvs_qparego, hvs_qehvi, hvs_qnehvi),\n",
        "        (\n",
        "            train_obj_true_random,\n",
        "            train_obj_true_qparego,\n",
        "            train_obj_true_qehvi,\n",
        "            train_obj_true_qnehvi,\n",
        "        ),\n",
        "    ):\n",
        "        # compute hypervolume\n",
        "        bd = DominatedPartitioning(ref_point=problem.ref_point, Y=train_obj)\n",
        "        volume = bd.compute_hypervolume().item()\n",
        "        hvs_list.append(volume)\n",
        "\n",
        "    # reinitialize the models so they are ready for fitting on next iteration\n",
        "    # Note: we find improved performance from not warm starting the model hyperparameters\n",
        "    # using the hyperparameters from the previous iteration\n",
        "    mll_qparego, model_qparego = initialize_model(train_x_qparego, train_obj_qparego)\n",
        "    mll_qehvi, model_qehvi = initialize_model(train_x_qehvi, train_obj_qehvi)\n",
        "    mll_qnehvi, model_qnehvi = initialize_model(train_x_qnehvi, train_obj_qnehvi)\n",
        "\n",
        "    t1 = time.monotonic()\n",
        "\n",
        "    if verbose:\n",
        "        print(\n",
        "            f\"\\nBatch {iteration:>2}: Hypervolume (random, qNParEGO, qEHVI, qNEHVI) = \"\n",
        "            f\"({hvs_random[-1]:>4.2f}, {hvs_qparego[-1]:>4.2f}, {hvs_qehvi[-1]:>4.2f}, {hvs_qnehvi[-1]:>4.2f}), \"\n",
        "            f\"time = {t1-t0:>4.2f}.\",\n",
        "            end=\"\",\n",
        "        )\n",
        "    else:\n",
        "        print(\".\", end=\"\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "72232578-0908-4292-aca4-d52197890dd6",
        "showInput": false
      },
      "source": [
        "#### Plot the results\n",
        "The plot below shows the a common metric of multi-objective optimization performance, the log hypervolume difference: the log difference between the hypervolume of the true pareto front and the hypervolume of the approximate pareto front identified by each algorithm. The log hypervolume difference is plotted at each step of the optimization for each of the algorithms.\n",
        "\n",
        "The plot shows that $q$NEHVI outperforms $q$EHVI, $q$ParEGO, and Sobol."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649857076,
        "executionStopTime": 1668649858100,
        "originalKey": "c9560130-5c74-4b2b-b24a-fd7618ee7822",
        "requestMsgId": "d6978d53-90e4-476b-bb1d-75010f65dcd6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7fd251ea2370>"
            ]
          },
          "execution_count": 15,
          "metadata": {
            "bento_obj_id": "140541294158704"
          },
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "bento_obj_id": "140541423428512",
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "import numpy as np\n",
        "from matplotlib import pyplot as plt\n",
        "\n",
        "%matplotlib inline\n",
        "\n",
        "\n",
        "iters = np.arange(N_BATCH + 1) * BATCH_SIZE\n",
        "log_hv_difference_qparego = np.log10(problem.max_hv - np.asarray(hvs_qparego))\n",
        "log_hv_difference_qehvi = np.log10(problem.max_hv - np.asarray(hvs_qehvi))\n",
        "log_hv_difference_qnehvi = np.log10(problem.max_hv - np.asarray(hvs_qnehvi))\n",
        "log_hv_difference_rnd = np.log10(problem.max_hv - np.asarray(hvs_random))\n",
        "\n",
        "fig, ax = plt.subplots(1, 1, figsize=(8, 6))\n",
        "ax.errorbar(\n",
        "    iters,\n",
        "    log_hv_difference_rnd,\n",
        "    label=\"Sobol\",\n",
        "    linewidth=1.5,\n",
        ")\n",
        "ax.errorbar(\n",
        "    iters,\n",
        "    log_hv_difference_qparego,\n",
        "    label=\"qNParEGO\",\n",
        "    linewidth=1.5,\n",
        ")\n",
        "ax.errorbar(\n",
        "    iters,\n",
        "    log_hv_difference_qehvi,\n",
        "    label=\"qEHVI\",\n",
        "    linewidth=1.5,\n",
        ")\n",
        "ax.errorbar(\n",
        "    iters,\n",
        "    log_hv_difference_qnehvi,\n",
        "    label=\"qNEHVI\",\n",
        "    linewidth=1.5,\n",
        ")\n",
        "ax.set(\n",
        "    xlabel=\"number of observations (beyond initial points)\",\n",
        "    ylabel=\"Log Hypervolume Difference\",\n",
        ")\n",
        "ax.legend(loc=\"lower left\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "originalKey": "824c329c-6c02-4f67-bce0-a4c57ea655d8",
        "showInput": false
      },
      "source": [
        "#### Plot the true objectives at the evaluated designs colored by iteration\n",
        "\n",
        "To examine optimization process from another perspective, we plot the true function values at the designs selected under each algorithm where the color corresponds to the BO iteration at which the point was collected. The plot on the right for $q$NEHVI shows that the $q$NEHVI quickly identifies the pareto front and most of its evaluations are very close to the pareto front. $q$NParEGO also identifies has many observations close to the pareto front, but relies on optimizing random scalarizations, which is a less principled way of optimizing the pareto front compared to $q$NEHVI, which explicitly attempts focuses on improving the pareto front. $q$EHVI uses the posterior mean as a plug-in estimator for the true function values at the in-sample points, whereas $q$NEHVI than integrating over the uncertainty at the in-sample designs Sobol generates random points and has few points close to the Pareto front."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649858641,
        "executionStopTime": 1668649859522,
        "originalKey": "cf610a77-3e82-4c30-ac7b-f7a97fa91fa5",
        "requestMsgId": "afb07e9c-ebaf-4a8e-90e3-ca426532de20"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Iteration')"
            ]
          },
          "execution_count": 16,
          "metadata": {
            "bento_obj_id": "140541356926672"
          },
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1656x504 with 5 Axes>"
            ]
          },
          "metadata": {
            "bento_obj_id": "140541327761568",
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "from matplotlib.cm import ScalarMappable\n",
        "\n",
        "\n",
        "fig, axes = plt.subplots(1, 4, figsize=(23, 7), sharex=True, sharey=True)\n",
        "algos = [\"Sobol\", \"qNParEGO\", \"qEHVI\", \"qNEHVI\"]\n",
        "cm = plt.get_cmap(\"viridis\")\n",
        "\n",
        "batch_number = torch.cat(\n",
        "    [\n",
        "        torch.zeros(2 * (problem.dim + 1)),\n",
        "        torch.arange(1, N_BATCH + 1).repeat(BATCH_SIZE, 1).t().reshape(-1),\n",
        "    ]\n",
        ").numpy()\n",
        "for i, train_obj in enumerate(\n",
        "    (\n",
        "        train_obj_true_random,\n",
        "        train_obj_true_qparego,\n",
        "        train_obj_true_qehvi,\n",
        "        train_obj_true_qnehvi,\n",
        "    )\n",
        "):\n",
        "    sc = axes[i].scatter(\n",
        "        train_obj[:, 0].cpu().numpy(),\n",
        "        train_obj[:, 1].cpu().numpy(),\n",
        "        c=batch_number,\n",
        "        alpha=0.8,\n",
        "    )\n",
        "    axes[i].set_title(algos[i])\n",
        "    axes[i].set_xlabel(\"Objective 1\")\n",
        "axes[0].set_ylabel(\"Objective 2\")\n",
        "norm = plt.Normalize(batch_number.min(), batch_number.max())\n",
        "sm = ScalarMappable(norm=norm, cmap=cm)\n",
        "sm.set_array([])\n",
        "fig.subplots_adjust(right=0.9)\n",
        "cbar_ax = fig.add_axes([0.93, 0.15, 0.01, 0.7])\n",
        "cbar = fig.colorbar(sm, cax=cbar_ax)\n",
        "cbar.ax.set_title(\"Iteration\")"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "python3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.11"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}
